import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.Arrays;
import java.util.Comparator;
import java.util.InputMismatchException;

/**
 * @author Egor Kulikov (egor@egork.net)
 */
public class BuyLand {
	@SuppressWarnings({"FieldCanBeLocal", "UnusedDeclaration"})
	private InputReader in;
	private PrintWriter out;

	public static class Complex {
		public static final Complex ONE = new Complex(1, 0) {
			@Override
			public Complex multiply(Complex other) {
				return other;
			}
		};
		public static final Complex ZERO = new Complex(0, 0) {
			@Override
			public Complex multiply(Complex other) {
				return ZERO;
			}

			@Override
			public Complex add(Complex other) {
				return other;
			}

			@Override
			public Complex divide(double by) {
				return ZERO;
			}
		};

		private double re;
		private double im;

		public Complex(double re, double im) {
			this.re = re;
			this.im = im;
		}

		public Complex multiply(Complex other) {
			return new Complex(re * other.re - im * other.im, re * other.im + im * other.re);
		}

		public Complex add(Complex other) {
			return new Complex(re + other.re, im + other.im);
		}

		public Complex subtract(Complex other) {
			return new Complex(re - other.re, im - other.im);
		}

		public Complex divide(double by) {
			return new Complex(re / by, im / by);
		}
	}

	public void fft(Complex[] a, boolean invert) {
		int size = a.length;

		for (int i = 1, j = 0; i < size; ++i) {
			int bit = size >> 1;
			for (; j >= bit; bit >>= 1) {
				j -= bit;
			}
			j += bit;
			if (i < j) {
				Complex temp = a[i];
				a[i] = a[j];
				a[j] = temp;
			}
		}

		for (int len = 2; len <= size; len <<= 1) {
			double ang = 2 * Math.PI / len * (invert ? -1 : 1);
			Complex wlen = new Complex(Math.cos(ang), Math.sin(ang));
			for (int i = 0; i < size; i += len) {
				Complex w = new Complex(1, 0);
				for (int j = 0; j < len / 2; j++) {
					shift(a, i + j, i + j + len / 2, w);
//					Complex u = a[i + j];
//					Complex v = a[i + j + len / 2].multiply(w);
//					a[i + j] = u.add(v);
//					a[i + j + len / 2] = u.subtract(v);
					double re = w.re;
					w.re = re * wlen.re - w.im * wlen.im;
					w.im = re * wlen.im + w.im * wlen.re;
				}
			}
		}
		if (invert) {
			for (int i = 0; i < size; ++i) {
				a[i] = a[i].divide(size);
			}
		}
	}

	public void fft(double[] are, double[] aim, boolean invert) {
		int size = are.length;

		for (int i = 1, j = 0; i < size; ++i) {
			int bit = size >> 1;
			for (; j >= bit; bit >>= 1) {
				j -= bit;
			}
			j += bit;
			if (i < j) {
				double temp = are[i];
				are[i] = are[j];
				are[j] = temp;
				temp = aim[i];
				aim[i] = aim[j];
				aim[j] = temp;
			}
		}

		for (int len = 2; len <= size; len <<= 1) {
			double ang = 2 * Math.PI / len * (invert ? -1 : 1);
			double wlenre = Math.cos(ang);
			double wlenim = Math.sin(ang);
			for (int i = 0; i < size; i += len) {
				double wre = 1;
				double wim = 0;
				for (int j = 0; j < len / 2; j++) {
					shift(are, aim, i + j, i + j + len / 2, wre, wim);
//					Complex u = a[i + j];
//					Complex v = a[i + j + len / 2].multiply(w);
//					a[i + j] = u.add(v);
//					a[i + j + len / 2] = u.subtract(v);
					double re = wre;
					wre = re * wlenre - wim * wlenim;
					wim = re * wlenim + wim * wlenre;
				}
			}
		}
		if (invert) {
			for (int i = 0; i < size; ++i) {
				are[i] /= size;
				aim[i] /= size;
//				a[i] = a[i].divide(size);
			}
		}
	}

	private void shift(Complex[] a, int index1, int index2, Complex w) {
		double re = a[index2].re * w.re - a[index2].im * w.im;
		double im = a[index2].re * w.im + a[index2].im * w.re;
		a[index2].re = a[index1].re - re;
		a[index2].im = a[index1].im - im;
		a[index1].re += re;
		a[index1].im += im;
	}

	private void shift(double[] are, double[] aim, int index1, int index2, double wre, double wim) {
		double re = are[index2] * wre - aim[index2] * wim;
		double im = are[index2] * wim + aim[index2] * wre;
		are[index2] = are[index1] - re;
		aim[index2] = aim[index1] - im;
		are[index1] += re;
		aim[index1] += im;
	}

	public int[] fastMultiply(int[] a, int[] b) {
		int size = 1;
		while (size < a.length || size < b.length) {
			size <<= 1;
		}
//		if (a.length + b.length - 1 > size)
//		size <<= 1;
//		Complex[] fa = new Complex[size];
//		Complex[] fb = new Complex[size];
		double[] fare = new double[size];
		double[] faim = new double[size];
		double[] fbre = new double[size];
		double[] fbim = new double[size];
		for (int i = 0; i < size; i++) {
			if (i < a.length) {
//				fa[i] = new Complex(a[i], 0);
				fare[i] = a[i];
			} else {
//				fa[i] = new Complex(0, 0);
			}
			if (i < b.length) {
//				fb[i] = new Complex(b[i], 0);
				fbre[i] = b[i];
			} else {
//				fb[i] = new Complex(0, 0);
			}
		}
//		fft(fa, false);
//		fft(fb, false);
		fft(fare, faim, false);
		fft(fbre, fbim, false);
		for (int i = 0; i < size; ++i) {
//			fa[i] = fa[i].multiply(fb[i]);
			double re = fare[i];
			fare[i] = re * fbre[i] - faim[i] * fbim[i];
			faim[i] = re * fbim[i] + faim[i] * fbre[i];
		}
//		fft(fa, true);
		fft(fare, faim, true);
		int[] result = new int[size];
		for (int i = 0; i < size; i++) {
//			if (fa[i].re > 0) {
//				result[i] = (int) (fa[i].re + 0.5);
//			} else {
//				result[i] = (int) (fa[i].re - 0.5);
//			}
			if (fare[i] > 0) {
				result[i] = (int) (fare[i] + 0.5);
			} else {
				result[i] = (int) (fare[i] - 0.5);
			}
		}
		return result;
	}

	private void solve() {
		long time = System.currentTimeMillis();
		int rowCount = in.readInt();
		final int columnCount = in.readInt();
		int[][] values = new int[rowCount][];
		for (int i = 0; i < rowCount; i++) {
			values[i] = in.readIntArray(columnCount);
		}
		int height = in.readInt();
		int width = in.readInt();
		int[][] sample = new int[height][];
		for (int i = 0; i < height; i++) {
			sample[i] = in.readIntArray(width);
		}
		int sampleSum = 0;
		int sampleSquareSum = 0;
		for (int i = 0; i < height; i++) {
			for (int j = 0; j < width; j++) {
				sampleSum += sample[i][j];
				sampleSquareSum += sample[i][j] * sample[i][j];
			}
		}
		int x = in.readInt() - 1;
		int y = in.readInt() - 1;
		int bestCount = in.readInt();
		int[] p = new int[rowCount * columnCount];
		int index = 0;
		for (int i = 0; i < rowCount; i++) {
			for (int j = 0; j < columnCount; j++) {
				p[index++] = values[i][j];
			}
		}
		int[] q = new int[(height - 1) * columnCount + width];
		for (int i = 0; i < height; i++) {
			for (int j = 0; j < width; j++) {
				q[i * columnCount + j] = sample[height - i - 1][width - j - 1];
			}
		}
		int[] mults = fastMultiply(p, q);
//		int[] check = multiply(p, q);
//		for (int i = 0; i < mults.length; i++) {
//			if (mults[i] != check[i])
//				throw new RuntimeException();
//		}
		int[][] sums = createSums(values, height, width);
		int[][] squares = new int[rowCount][columnCount];
		for (int i = 0; i < rowCount; i++) {
			for (int j = 0; j < columnCount; j++) {
				squares[i][j] = values[i][j] * values[i][j];
			}
		}
		int[][] sumSquares = createSums(squares, height, width);
		final int[][] cost = new int[rowCount - height + 1][columnCount - width + 1];
		final int costWidth = cost[0].length;
		for (int i = 0; i < cost.length; i++) {
			for (int j = 0; j < costWidth; j++) {
				cost[i][j] = sumSquares[i][j] + sampleSquareSum - 2 * mults[q.length - 1 + i * columnCount + j];
				cost[i][j] -= 2 * values[i + x][j + y] * (sums[i][j] - sampleSum);
				cost[i][j] += squares[i + x][j + y] * height * width;
				if (cost[i][j] < 0) {
					throw new RuntimeException();
				}
			}
		}
//		out.println(q.length - 1 + (cost.length - 1) * columnCount + costWidth);
//		out.println(p.length);
		Integer[] order = new Integer[cost.length * costWidth];
		for (int i = 0; i < order.length; i++) {
			order[i] = i;
		}
		final int[] row = new int[order.length];
		final int[] column = new int[order.length];
		for (int i = 0; i < order.length; i++) {
			row[i] = i / costWidth;
			column[i] = i % costWidth;
		}
		Arrays.sort(order, new Comparator<Integer>() {
			public int compare(Integer o1, Integer o2) {
				int cost1 = cost[row[o1]][column[o1]];
				int cost2 = cost[row[o2]][column[o2]];
				if (cost1 != cost2) {
					return cost1 - cost2;
				}
				return o1 - o2;
			}
		});
		for (int i = 0; i < bestCount; i++) {
			out.println((row[order[i]] + 1) + " " + (column[order[i]] + 1) + " " +
				cost[row[order[i]]][column[order[i]]]);
		}
		System.err.println(System.currentTimeMillis() - time);
	}

	private int[][] createSums(int[][] values, int height, int width) {
		int[][] sums = new int[values.length - height + 1][values[0].length - width + 1];
		int[][] columnSums = new int[sums.length][values[0].length];
		for (int i = 0; i < values[0].length; i++) {
			int sum = 0;
			for (int j = 0; j < height; j++) {
				sum += values[j][i];
			}
			columnSums[0][i] = sum;
			for (int j = height; j < values.length; j++) {
				sum += values[j][i];
				sum -= values[j - height][i];
				columnSums[j - height + 1][i] = sum;
			}
		}
		for (int i = 0; i < sums.length; i++) {
			int sum = 0;
			for (int j = 0; j < width; j++) {
				sum += columnSums[i][j];
			}
			sums[i][0] = sum;
			for (int j = width; j < columnSums[i].length; j++) {
				sum += columnSums[i][j];
				sum -= columnSums[i][j - width];
				sums[i][j - width + 1] = sum;
			}
		}
		return sums;
	}

	private int[] multiply(int[] p, int[] q) {
		int[] result = new int[p.length + q.length - 1];
		return multiply(p, 0, p.length, q, 0, q.length, result);
	}

	private int[] multiply(int[] p, int fromP, int toP, int[] q, int fromQ, int toQ, int[] result) {
		while (fromP < toP && p[fromP] == 0) {
			fromP++;
		}
		while (fromP < toP && p[toP - 1] == 0) {
			toP--;
		}
		while (fromQ < toQ && q[fromQ] == 0) {
			fromQ++;
		}
		while (fromQ < toQ && q[toQ - 1] == 0) {
			toQ--;
		}
		int pLength = toP - fromP;
		int qLength = toQ - fromQ;
		int n = Math.max(pLength, qLength) / 2;
		if (n <= 10) {
			for (int i = fromP; i < toP; i++) {
				for (int j = fromQ; j < toQ; j++) {
					result[i + j] += p[i] * q[j];
				}
			}
			return result;
		}
		if (pLength == 0) {
			return result;
		}
		if (qLength == 0) {
			return result;
		}
		if (n == 0) {
			result[fromP + fromQ] += p[fromP] * q[fromQ];
//			return new int[]{p[fromP] * q[fromQ]};
			return result;
		}
		int[] a;
		int fromA;
		int toA;
		int[] b;
		int fromB;
		int toB;
		if (pLength > n) {
			a = p;
			fromA = fromP;
			toA = fromP + n;
			b = p;
			fromB = fromP + n;
			toB = toP;
		} else {
			a = p;
			fromA = fromP;
			toA = toP;
			b = p;
			fromB = toP;
			toB = toP;
		}
		int[] c;
		int fromC;
		int toC;
		int[] d;
		int fromD;
		int toD;
		if (qLength > n) {
			c = q;
			fromC = fromQ;
			toC = fromQ + n;
			d = q;
			fromD = fromQ + n;
			toD = toQ;
		} else {
			c = q;
			fromC = fromQ;
			toC = toQ;
			d = q;
			fromD = toQ;
			toD = toQ;
		}
		int[] ac = multiply(a, fromA, toA, c, fromC, toC, result);
		int[] bd = multiply(b, fromB, toB, d, fromD, toD, result);
		int aLength = toA - fromA;
		int bLength = toB - fromB;
		int[] apb = new int[Math.max(aLength, bLength)];
		for (int i = 0, j = fromA; i < aLength; i++, j++) {
			apb[i] += a[j];
		}
		for (int i = 0, j = fromB; i < bLength; i++, j++) {
			apb[i] += b[j];
		}
		int cLength = toC - fromC;
		int dLength = toD - fromD;
		int[] cpd = new int[Math.max(cLength, dLength)];
		for (int i = 0, j = fromC; i < cLength; i++, j++) {
			cpd[i] += c[j];
		}
		for (int i = 0, j = fromD; i < dLength; i++, j++) {
			cpd[i] += d[j];
		}
		int[] abcd = multiply(apb, cpd);
		int acLength = Math.min(aLength + cLength - 1, abcd.length);
		int acShift = fromA + fromC;
		int bdLength = Math.min(bLength + dLength - 1, abcd.length);
		int bdShift = fromB + fromD;
		for (int i = 0, j = acShift; i < acLength; i++, j++) {
			abcd[i] -= ac[j];
		}
		for (int j = 0, i = bdShift; j < bdLength; j++, i++) {
			abcd[j] -= bd[i];
		}
//		int[] result = new int[pLength + qLength - 1];
		int shift = fromP + fromQ + n;
//		for (int i = 0; i < ac.length && shift + i < result.length; i++)
//			result[shift + i] += ac[i];
//		for (int i = 0; i < bd.length && i + 2 * n < result.length; i++)
//			result[i + 2 * n] += bd[i];
		for (int i = 0, j = shift; i < abcd.length/* && i + shift < result.length*/; i++, j++) {
			result[j] += abcd[i];
		}
		return result;
	}

	public static void main(String[] args) {
		new BuyLand().run();
	}

	private BuyLand() {
		@SuppressWarnings({"UnusedDeclaration"})
		String id = getClass().getName().toLowerCase();
		//noinspection EmptyTryBlock
		try {
//			System.setIn(new FileInputStream(id + ".in"));
//			System.setOut(new PrintStream(new FileOutputStream(id + ".out")));
//			System.setIn(new FileInputStream("test.txt"));
//			System.setOut(new PrintStream(new FileOutputStream("output.txt")));
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
		in = new InputReader(System.in);
		out = new PrintWriter(System.out);
	}

	private void run() {
		//noinspection InfiniteLoopStatement
//		while (true)
//		int testCount = in.readInt();
//		for (int i = 0; i < testCount; i++)
		solve();
		exit();
	}

	@SuppressWarnings({"UnusedDeclaration"})
	private void exit() {
		out.close();
		System.exit(0);
	}

	@SuppressWarnings({"UnusedDeclaration"})
	private static class InputReader {
		private InputStream stream;
		private byte[] buf = new byte[1024];
		private int curChar, numChars;

		public InputReader(InputStream stream) {
			this.stream = stream;
		}

		public int read() {
			if (numChars == -1) {
				throw new InputMismatchException();
			}
			if (curChar >= numChars) {
				curChar = 0;
				try {
					numChars = stream.read(buf);
				} catch (IOException e) {
					throw new InputMismatchException();
				}
				if (numChars <= 0) {
					return -1;
				}
			}
			return buf[curChar++];
		}

		public int readInt() {
			int c = read();
			while (isSpaceChar(c)) {
				c = read();
			}
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = read();
			}
			int res = 0;
			do {
				if (c < '0' || c > '9') {
					throw new InputMismatchException();
				}
				res *= 10;
				res += c - '0';
				c = read();
			} while (!isSpaceChar(c));
			return res * sgn;
		}

		public long readLong() {
			int c = read();
			while (isSpaceChar(c)) {
				c = read();
			}
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = read();
			}
			long res = 0;
			do {
				if (c < '0' || c > '9') {
					throw new InputMismatchException();
				}
				res *= 10;
				res += c - '0';
				c = read();
			} while (!isSpaceChar(c));
			return res * sgn;
		}

		public String readString() {
			int c = read();
			while (isSpaceChar(c)) {
				c = read();
			}
			StringBuffer res = new StringBuffer();
			do {
				res.appendCodePoint(c);
				c = read();
			} while (!isSpaceChar(c));
			return res.toString();
		}

		private boolean isSpaceChar(int c) {
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}

		private String readLine0() {
			StringBuffer buf = new StringBuffer();
			int c = read();
			while (c != '\n' && c != -1) {
				if (c != '\r') {
					buf.appendCodePoint(c);
				}
				c = read();
			}
			return buf.toString();
		}

		public String readLine() {
			String s = readLine0();
			while (s.trim().length() == 0) {
				s = readLine0();
			}
			return s;
		}

		public String readLine(boolean ignoreEmptyLines) {
			if (ignoreEmptyLines) {
				return readLine();
			} else {
				return readLine0();
			}
		}

		public BigInteger readBigInteger() {
			try {
				return new BigInteger(readString());
			} catch (NumberFormatException e) {
				throw new InputMismatchException();
			}
		}

		public char readCharacter() {
			int c = read();
			while (isSpaceChar(c)) {
				c = read();
			}
			return (char) c;
		}

		public double readDouble() {
			int c = read();
			while (isSpaceChar(c)) {
				c = read();
			}
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = read();
			}
			double res = 0;
			while (!isSpaceChar(c) && c != '.') {
				if (c == 'e' || c == 'E') {
					return res * Math.pow(10, readInt());
				}
				if (c < '0' || c > '9') {
					throw new InputMismatchException();
				}
				res *= 10;
				res += c - '0';
				c = read();
			}
			if (c == '.') {
				c = read();
				double m = 1;
				while (!isSpaceChar(c)) {
					if (c == 'e' || c == 'E') {
						return res * Math.pow(10, readInt());
					}
					if (c < '0' || c > '9') {
						throw new InputMismatchException();
					}
					m /= 10;
					res += (c - '0') * m;
					c = read();
				}
			}
			return res * sgn;
		}

		public int[] readIntArray(int size) {
			int[] array = new int[size];
			for (int i = 0; i < size; i++) {
				array[i] = readInt();
			}
			return array;
		}

		public long[] readLongArray(int size) {
			long[] array = new long[size];
			for (int i = 0; i < size; i++) {
				array[i] = readLong();
			}
			return array;
		}

		public double[] readDoubleArray(int size) {
			double[] array = new double[size];
			for (int i = 0; i < size; i++) {
				array[i] = readDouble();
			}
			return array;
		}

		public String[] readStringArray(int size) {
			String[] array = new String[size];
			for (int i = 0; i < size; i++) {
				array[i] = readString();
			}
			return array;
		}

		public char[][] readTable(int rowCount, int columnCount) {
			char[][] table = new char[rowCount][columnCount];
			for (int i = 0; i < rowCount; i++) {
				for (int j = 0; j < columnCount; j++) {
					table[i][j] = readCharacter();
				}
			}
			return table;
		}

		public void readIntArrays(int[]... arrays) {
			for (int i = 0; i < arrays[0].length; i++) {
				for (int j = 0; j < arrays.length; j++) {
					arrays[j][i] = readInt();
				}
			}
		}
	}
}
